
package com.click.app.webapp.action;

import com.click.app.DateFormatChanger;
import com.click.app.Functions;
import com.click.app.model.AsignationCut;
import com.click.app.model.BalanceEmployee;
import com.click.app.model.CutDetail;
import com.click.app.model.CutProcess;
import com.click.app.model.Employee;
import com.click.app.model.Material;
import com.click.app.model.Model;
import com.click.app.model.ModelSize;
import com.click.app.model.PackageDetail;
import com.click.app.model.PantDesign;
import com.click.app.model.PeriodPaymentEmployee;
import com.click.app.model.PurchaseDetailCutProcess;
import com.click.app.model.TransactionUser;
import com.click.app.service.AsignationCutManager;
import com.click.app.service.BalanceEmployeeManager;
import com.click.app.service.CutDetailManager;
import com.click.app.service.CutProcessManager;
import com.click.app.service.EmployeeManager;
import com.click.app.service.GenericManager;
import com.click.app.service.MaterialManager;
import com.click.app.service.PackageDetailManager;
import com.click.app.service.PantDesignManager;
import com.click.app.service.PeriodPaymentEmployeeManager;
import com.click.app.service.TransactionUserManager;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.util.JRLoader;

/**
 *
 * @author ariel
 */
public class CutProcessAction extends BaseAction {

    private CutProcessManager cutProcessManager;
    private AsignationCutManager asignationCutManager;
    private EmployeeManager employeeManager;
    private PackageDetailManager packageDetailManager;
    private List<CutProcess> cutProcesses;
    private List<CutDetail> listCutDetails;
    private CutProcess cutProcess;
    private Long id;
    private List<AsignationCut> asignationCutList;
    private AsignationCut asignationCut;
    private Integer asignationCutIndex;
    private GenericManager<Model, Long> modelManager;
    private List<Model> listModels;
    private GenericManager<ModelSize, Long> modelSizeManager;
    private List<ModelSize> listModelSizes;
    private MaterialManager materialManager;
    private List<Material> listMaterials;
    private String choiceModel;
    private String choiceModelSize;
    private String choiceMaterial;
    private Integer choiceQuantity;
    private String cutDetailIndex;
    private String cutDetailId;
    private Long idCutDetail;
    private PantDesign pantDesign;
    private PantDesignManager pantDesignManager;
    private Long idTemp;
    private CutDetailManager cutDetailManager;
    private CutDetail cutDetail;
    private String initDateCuProcess;
    private List<AsignationCut> listAsignationCuts;
    private List<PurchaseDetailCutProcess> listPurchaseDetailCutProcess = new ArrayList<PurchaseDetailCutProcess>();
    private BalanceEmployeeManager balanceEmployeeManager;
    private String endDateCutProcess;
    private PeriodPaymentEmployeeManager periodPaymentEmployeeManager;
    private List<Employee> employeesList;
    private List<CutProcess> listCutProcess;
    private Map reportParams;

    private TransactionUserManager transactionUserManager;

    public void setId(Long id) {
        this.id = id;
    }

    public CutProcess getCutProcess() {
        return cutProcess;
    }

    public void setCutProcess(CutProcess cutProcess) {
        this.cutProcess = cutProcess;
    }

    public AsignationCut getAsignationCut() {
        return asignationCut;
    }

    public void setAsignationCut(AsignationCut asignationCut) {
        this.asignationCut = asignationCut;
    }

    public List<AsignationCut> getAsignationCutList() {
        return asignationCutList;
    }

    public Integer getAsignationCutIndex() {
        return asignationCutIndex;
    }

    public void setPantDesignManager(PantDesignManager pantDesignManager) {
        this.pantDesignManager = pantDesignManager;
    }

    public void setAsignationCutIndex(Integer asignationCutIndex) {
        this.asignationCutIndex = asignationCutIndex;
    }

    public String generateJasperReportAsign() {
        System.out.println("CutProcessAction -> generateJasperReportAsign()");
        Long idCutProcess = (Long)getSession().getAttribute("idCutProcess");
        cutProcess = cutProcessManager.get(idCutProcess);
        cutProcesses=new ArrayList<CutProcess>();
        cutProcesses.add(cutProcess);
        listCutDetails = cutProcess.getCutDetail();

        String pathSubReport = getRequest().getSession().getServletContext().getRealPath("/reports/cutProcessSubReport.jasper");
        try {
              JasperReport subReport = (JasperReport) JRLoader.loadObject(new File(pathSubReport));
              TransactionUser transaction = new TransactionUser();
              transaction = transactionUserManager.save(transaction);

              String codeTransaction = transaction.getId().toString();
              String date = cutProcess.getInitDate().toString()+"##"+cutProcess.getEndDate().toString();
              String nameTransaction = "ASING CUT PROCESS";
              String code = codeTransaction+"##"+date+"##"+nameTransaction;
              String newCodeTransaction = Functions.getCodePrintTransaction(code);

              reportParams = new HashMap();
              reportParams.put("subReport", subReport);
              reportParams.put("labelCodeTransaction", getText("codeTransaction"));
              reportParams.put("codeTransaction", newCodeTransaction);
              reportParams.put("labelTitle", getText("cutProcess.title"));
              
              reportParams.put("sLabelTitle", getText("cutProcessForm.tableCutDetail"));
              reportParams.put("sLabelModel", getText("cutProcessForm.asignationDetail.model"));
              reportParams.put("sLabelSize", getText("cutProcessForm.asignationDetail.size"));
              reportParams.put("sLabelMaterial", getText("cutProcessForm.asignationDetail.typeMaterial"));

              reportParams.put("labelNameEmployee", getText("nameEmployee"));
              reportParams.put("nameEmployee", cutProcess.getEmployee().getFullName());
              reportParams.put("labelDate", getText("date"));
              reportParams.put("date", cutProcess.getInitDate().toString()+" - "+cutProcess.getEndDate().toString());
              
        } catch (JRException ex) {
            Logger.getLogger(PurchaseDetailAction.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("CutProcessAction -> end generateJasperReportAsign()");
        return SUCCESS;
    }

    public String generateJasperReportReview() {
        System.out.println("CutProcessAction -> generateJasperReportReview()");
        Long idCutProcess = (Long)getSession().getAttribute("idCutProcess");
        cutProcess = cutProcessManager.get(idCutProcess);
        cutProcesses=new ArrayList<CutProcess>();
        cutProcesses.add(cutProcess);
        listCutDetails = cutProcess.getCutDetail();

        String pathSubReport = getRequest().getSession().getServletContext().getRealPath("/reports/cutProcessDetailReviewSR.jasper");
        try {
              JasperReport subReportCutDetails = (JasperReport) JRLoader.loadObject(new File(pathSubReport));
              TransactionUser transaction = new TransactionUser();
              transaction = transactionUserManager.save(transaction);

              String codeTransaction = transaction.getId().toString();
              String date = cutProcess.getInitDate().toString()+"##"+cutProcess.getEndDate().toString();
              String nameTransaction = "ASING CUT PROCESS REVIEW";
              String code = codeTransaction+"##"+date+"##"+nameTransaction;
              String newCodeTransaction = Functions.getCodePrintTransaction(code);

              reportParams = new HashMap();
              reportParams.put("subReportCutDetails", subReportCutDetails);
              reportParams.put("labelCodeTransaction", getText("codeTransaction"));
              reportParams.put("codeTransaction", newCodeTransaction);
              reportParams.put("labelTitle", getText("cutProcess.title"));

              reportParams.put("labelTotalAmount", getText("cutProcessForm.asignationDetail.totalAmount"));
              reportParams.put("totalAmount", cutProcess.getTotalAmount().toString());
              reportParams.put("labelTotalAmountFail", getText("cutProcess.totalAmountFail"));
              reportParams.put("totalAmountFail", cutProcess.getTotalAmountFail().toString());
              reportParams.put("labelTotalRealAmount", getText("cutProcess.totalRealAmount"));
              reportParams.put("totalRealAmount", cutProcess.getTotalRealAmount().toString());
              
              reportParams.put("sLabelTitle", getText("cutProcessForm.tableCutDetail"));
              reportParams.put("sLabelModel", getText("cutProcessForm.asignationDetail.model"));
              reportParams.put("sLabelSize", getText("cutProcessForm.asignationDetail.size"));
              reportParams.put("sLabelMaterial", getText("cutProcessForm.asignationDetail.typeMaterial"));
              reportParams.put("sLabelQuantityGet", getText("cutProcessForm.asignationDetail.totalCuts"));
              reportParams.put("sLabelPriceXclothes", getText("cutProcessForm.asignationDetail.priceXclothes"));
              reportParams.put("sLabelTotalAmountClothes", getText("cutProcessForm.asignationDetail.totalAmount"));

              reportParams.put("labelNameEmployee", getText("nameEmployee"));
              reportParams.put("nameEmployee", cutProcess.getEmployee().getFullName());
              reportParams.put("labelDate", getText("date"));
              reportParams.put("date", cutProcess.getInitDate().toString()+" - "+cutProcess.getEndDate().toString());

        } catch (JRException ex) {
            Logger.getLogger(PurchaseDetailAction.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("CutProcessAction -> end generateJasperReportReview()");
        return SUCCESS;
    }

    public String deleteAsignationCut() {
        System.out.println("deleteAsignationCut() ");

        asignationCutList = (List<AsignationCut>) getSession().getAttribute("asignationCutList");

        asignationCut = asignationCutList.get(asignationCutIndex);

        if (asignationCut.getId() != null) {
            List<AsignationCut> deleteAsignationCutList = (List<AsignationCut>) getSession().getAttribute("deleteAsignationCutList");
            deleteAsignationCutList.add(asignationCut);
            getSession().setAttribute("deleteAsignationCutList", deleteAsignationCutList);
        }

        asignationCutList.remove(asignationCut);

        getSession().setAttribute("asignationCutList", asignationCutList);

        asignationCut = new AsignationCut();
        asignationCutIndex = null;

        return SUCCESS;
    }

    public String delete() {
        System.out.println("CutProcessAction -> delete()");
        if (id != null) {
            cutProcess = cutProcessManager.get(id);
            if (cutProcess.getDeleted()) {
                BalanceEmployee balanceEmployee = balanceEmployeeManager.getByIdCutProcess(id);
                balanceEmployeeManager.remove(balanceEmployee.getId());
                cutProcessManager.remove(id);

                System.out.println("CutProcessAction -> end delete()");
                saveMessage(getText("cutProcess.deleted"));
                return SUCCESS;
            }
        }
        getSession().removeAttribute("asignationCutList");
        getSession().removeAttribute("deleteAsignationCutList");
        getSession().removeAttribute("listCutDetails");
        errorMessage(getText("cutProcess.deleted.error"));
        System.out.println("CutProcessAction -> end delete() -> error");

        return ERROR;
    }

    public String edit() {
        if (id != null) {
            cutProcess = cutProcessManager.getById(id);
            listCutDetails = cutProcess.getCutDetail();

            getSession().setAttribute("idCutProcess", id);
            return INPUT;
        } else {
            cutProcess = new CutProcess();
            asignationCutList = new ArrayList<AsignationCut>();
            asignationCut = new AsignationCut();
            listCutDetails = new ArrayList<CutDetail>();
            getSession().setAttribute("asignationCutList", asignationCutList);
            getSession().setAttribute("deleteAsignationCutList", new ArrayList<AsignationCut>());

        }

        choiceQuantity = 1;
        employeesList = employeeManager.findByRole("ROLE_EMPLOYEE_CUTTER");

        getSession().setAttribute("listCutDetails", listCutDetails);
        return SUCCESS;
    }

    public String editCutProcessReview() {
        if (id == null) {
            if (getSession().getAttribute("idCutProcess") != null) {
                id = (Long) getSession().getAttribute("idCutProcess");
            }
        }
        if (id != null) {
            cutProcess = cutProcessManager.getById(id);
            endDateCutProcess = DateFormatChanger.changeDatetoString(cutProcess.getEndDate());
            listCutDetails = cutProcess.getCutDetail();
            listAsignationCuts = cutProcess.getAsignationCuts();
            listPurchaseDetailCutProcess = cutProcess.getListPurchaseDetailCutProcess();
            getSession().setAttribute("idCutProcess", id);
        }
        choiceQuantity = 1;
        return SUCCESS;
    }

    public String save() throws Exception {
        System.out.println("CutProcessAction -> save()");

        //      boolean isNew = (cutProcess.getId() == null);

//        List<AsignationCut> deleteAsignationCutList = (List<AsignationCut>) getSession().getAttribute("deleteAsignationCutList");
//        for (AsignationCut a : deleteAsignationCutList) {
//            asignationCutManager.remove(a.getId());
//        }

//        cutProcess.setEmployee(employeeManager.get(cutProcess.getEmployee().getId()));
//        cutProcess.setDeleted(true);
//        cutProcess.setTotalAmount(0.0f);
//        cutProcess.setTotalAmountFail(0.0f);
//        cutProcess.setTotalCurrentAmount(0.0f);
//        cutProcess.setTotalRealAmount(0.0f);
//        cutProcess = cutProcessManager.save(cutProcess);
//
//        BalanceEmployee balanceEmployee  = new BalanceEmployee();
//        balanceEmployee.set

//        asignationCutList = (List<AsignationCut>) getSession().getAttribute("asignationCutList");
//        for (AsignationCut a : asignationCutList) {
//            if (a.getId() == null) {
//                a.setCutProcess(cutProcess);
//            }
//
//            asignationCutManager.save(a);
//        }
//
//        String key = (isNew) ? "cutProcess.added" : "cutProcess.updated";
//        saveMessage(getText(key));
//
//        getSession().removeAttribute("asignationCutList");
//        getSession().removeAttribute("deleteAsignationCutList");
        System.out.println("CutProcessAction -> end save()");
        return SUCCESS;
    }

    @Override
    public String cancel() {
        getSession().removeAttribute("asignationCutList");
        getSession().removeAttribute("deleteAsignationCutList");

        return CANCEL;
    }

    public void setCutProcessManager(CutProcessManager cutProcessManager) {
        this.cutProcessManager = cutProcessManager;
    }

    public void setAsignationCutManager(AsignationCutManager asignationCutManager) {
        this.asignationCutManager = asignationCutManager;
    }

    public void setEmployeeManager(EmployeeManager employeeManager) {
        this.employeeManager = employeeManager;
    }

    public void setPackageDetailManager(PackageDetailManager packageDetailManager) {
        this.packageDetailManager = packageDetailManager;
    }

    public List<Model> getModelList() {
        return modelManager.getAll();
    }

    public List<ModelSize> getModelSizeList() {
        return modelSizeManager.getAll();
    }

    public List<CutProcess> getCutProcesses() {
        return cutProcesses;
    }

    public String list() {
        getSession().removeAttribute("idCutProcess");
        cutProcesses = cutProcessManager.getCutProcesses();
        return SUCCESS;
    }

    public String cutProcessReviewList() {
        cutProcesses = cutProcessManager.getCutProcesses();
        return SUCCESS;
    }

    public List<Employee> getEmployeesList() {
        return employeesList;
    }

    public List<PackageDetail> getPackageDetailList() {
        return packageDetailManager.packagesAvailable();
    }

    public GenericManager<Model, Long> getModelManager() {
        return modelManager;
    }

    public void setModelManager(GenericManager<Model, Long> modelManager) {
        this.modelManager = modelManager;
    }

    public List<Model> getListModels() {
        return modelManager.getAll();
    }

    public void setListModels(List<Model> listModels) {
        this.listModels = listModels;
    }

    public GenericManager<ModelSize, Long> getModelSizeManager() {
        return modelSizeManager;
    }

    public void setModelSizeManager(GenericManager<ModelSize, Long> modelSizeManager) {
        this.modelSizeManager = modelSizeManager;
    }

    public List<ModelSize> getListModelSizes() {
        return modelSizeManager.getAll();
    }

    public void setListModelSizes(List<ModelSize> listModelSizes) {
        this.listModelSizes = listModelSizes;
    }

    public MaterialManager getMaterialManager() {
        return materialManager;
    }

    public void setMaterialManager(MaterialManager materialManager) {
        this.materialManager = materialManager;
    }

    public List<Material> getListMaterials() {
        if (listMaterials == null) {
            List<String> names = new ArrayList<String>();
            names.add("tipoMaterial");

            List<String> values = new ArrayList<String>();
            values.add("jean");

            List<String> opNames = new ArrayList<String>();
            opNames.add("=");

            List<String> opValues = new ArrayList<String>();
            opValues.add("=");

            List<String> joinsFields = new ArrayList<String>();

            listMaterials = materialManager.findMaterialByDistintive(names, opNames, values, opValues, joinsFields);

        }
        return listMaterials;
    }

    public void setListMaterials(List<Material> listMaterials) {
        this.listMaterials = listMaterials;
    }

    public String getChoiceModel() {
        return choiceModel;
    }

    public void setChoiceModel(String choiceModel) {
        this.choiceModel = choiceModel;
    }

    public String getChoiceModelSize() {
        return choiceModelSize;
    }

    public void setChoiceModelSize(String choiceModelSize) {
        this.choiceModelSize = choiceModelSize;
    }

    public String getChoiceMaterial() {
        return choiceMaterial;
    }

    public void setChoiceMaterial(String choiceMaterial) {
        this.choiceMaterial = choiceMaterial;
    }

    public Integer getChoiceQuantity() {
        return choiceQuantity;
    }

    public void setChoiceQuantity(Integer choiceQuantity) {
        this.choiceQuantity = choiceQuantity;
    }

    public List<CutDetail> getListCutDetails() {
        return listCutDetails;
    }

    public void setListCutDetails(List<CutDetail> listCutDetails) {
        this.listCutDetails = listCutDetails;
    }

    public String getCutDetailIndex() {
        return cutDetailIndex;
    }

    public void setCutDetailIndex(String cutDetailIndex) {
        this.cutDetailIndex = cutDetailIndex;
    }

    public String getCutDetailId() {
        return cutDetailId;
    }

    public void setCutDetailId(String cutDetailId) {
        this.cutDetailId = cutDetailId;
    }

    public String saveCutProcess() {
        System.out.println("CutProcessAction -> saveCutProcess()");

        if (cutProcess.getEmployee().getId() != -1 && initDateCuProcess != null) {
            Employee employee = employeeManager.get(cutProcess.getEmployee().getId());
            cutProcess.setEmployee(employee);
            cutProcess.setInitDate(DateFormatChanger.changeStringtoDate(initDateCuProcess));
            cutProcess.setEndDate(cutProcess.getInitDate());
            cutProcess.setDeleted(true);
            cutProcess.setTotalAmount(0.0D);
            cutProcess.setTotalRealAmount(0.0D);
            cutProcess.setTotalCurrentAmount(0.0D);
            cutProcess.setTotalAmountFail(0.0D);
            cutProcess = cutProcessManager.save(cutProcess);

            PeriodPaymentEmployee periodPaymentEmployee = periodPaymentEmployeeManager.getCurrentPeriodByIdEmployeeAndRole(employee.getId(), employee.getRoleByName("ROLE_EMPLOYEE_CUTTER").getIdRole());
            BalanceEmployee balanceEmployee = new BalanceEmployee();

            balanceEmployee.setBalance(periodPaymentEmployee.getCurrentAmount());
            balanceEmployee.setAmountPaid(0.0D);
            balanceEmployee.setAmountWon(0.0D);
            balanceEmployee.setCutProcess(cutProcess);
            balanceEmployee.setDateBalance(cutProcess.getInitDate());
            balanceEmployee.setPeriodPaymentEmployee(periodPaymentEmployee);
            balanceEmployee.setPaymentsCut(null);
            balanceEmployee.setPaymentsPant(null);
            balanceEmployee.setProcessDressmaker(null);
            balanceEmployee = balanceEmployeeManager.save(balanceEmployee);
            cutProcess.setBalanceEmployee(balanceEmployee);
            balanceEmployeeManager.save(balanceEmployee);
            cutProcess = cutProcessManager.save(cutProcess);

            getSession().setAttribute("idCutProcess", cutProcess.getId());
            System.out.println("End save cut process ...");
            return SUCCESS;

        } else {
            errorMessage(getText("cutProcessAction.errorSaveCutProcess"));
            return ERROR;
        }
    }

    public String saveCutProcessReview() {
        System.out.println("CutProcessAction -> saveCutProcessReview()");
        CutProcess cutProcessAux = cutProcessManager.get(cutProcess.getId());
        if (cutProcessAux.getInitDate().compareTo(DateFormatChanger.changeStringtoDate(endDateCutProcess)) <= 0) {
            cutProcessAux.setEndDate(DateFormatChanger.changeStringtoDate(endDateCutProcess));
            cutProcessManager.save(cutProcessAux);
            saveMessage(getText("cutProcessAction.updateCutProcess"));
            return SUCCESS;
        }
        errorMessage(getText("cutProcessAction.errorDateLessThan"));
        return ERROR;
    }

    public String addCutDetailToCutProcess() {
        cutProcess = cutProcessManager.get((Long) getSession().getAttribute("idCutProcess"));
        listCutDetails = cutProcess.getCutDetail();
        return SUCCESS;
    }

    public String doneAddCutDetail() {
        getSession().removeAttribute("asignationCutList");
        getSession().removeAttribute("deleteAsignationCutList");
        return SUCCESS;
    }

    public String reasignCutDetail() {
        if (id != null) {
            cutDetail = cutDetailManager.get(id);
            cutProcesses = cutProcessManager.getAll();
        }
        return SUCCESS;
    }

    public String saveReAsignationCutDetail() {
        if (!cutDetail.getCutProcess().getId().equals(-1)) {

            CutDetail cutDetailAux = cutDetailManager.get(cutDetail.getId());
            CutProcess cutProcessAux = cutProcessManager.get(cutDetail.getCutProcess().getId());
            cutDetailAux.setCutProcess(cutProcessAux);
            cutDetailManager.save(cutDetailAux);
            cutDetail = cutDetailManager.get(cutDetail.getId());
            cutProcesses = cutProcessManager.getAll();
            saveMessage(getText("cutProcessAction.reasignSuccess"));
            return INPUT;
        }
        cutDetail = cutDetailManager.get(cutDetail.getId());
        cutProcesses = cutProcessManager.getAll();
        saveMessage(getText("cutProcessAction.errorData-1"));
        return ERROR;

    }

    public Long getIdCutDetail() {
        return idCutDetail;
    }

    public void setIdCutDetail(Long idCutDetail) {
        this.idCutDetail = idCutDetail;
    }

    public PantDesign getPantDesign() {
        return pantDesign;
    }

    public void setPantDesign(PantDesign pantDesign) {
        this.pantDesign = pantDesign;
    }

    public String deleteCutDetail() {
        if (id != null) {
            cutDetail = cutDetailManager.get(id);
            if (cutDetail.isModify()) {
                cutDetailManager.remove(id);
                saveMessage(getText("cutProcessAction.deleteCutDetail"));
                return SUCCESS;
            }
        }
        errorMessage(getText("cutProcessAction.errorDeleteCutDetail"));
        return ERROR;
    }

    public CutDetailManager getCutDetailManager() {
        return cutDetailManager;
    }

    public void setCutDetailManager(CutDetailManager cutDetailManager) {
        this.cutDetailManager = cutDetailManager;
    }

    public Long getIdTemp() {
        return idTemp;
    }

    public void setIdTemp(Long idTemp) {
        this.idTemp = idTemp;
    }

    public CutDetail getCutDetail() {
        return cutDetail;
    }

    public void setCutDetail(CutDetail cutDetail) {
        this.cutDetail = cutDetail;
    }

    public Long getId() {
        return id;
    }

    public List<AsignationCut> getListAsignationCuts() {
        return listAsignationCuts;
    }

    public void setListAsignationCuts(List<AsignationCut> listAsignationCuts) {
        this.listAsignationCuts = listAsignationCuts;
    }

    public List<PurchaseDetailCutProcess> getListPurchaseDetailCutProcess() {
        return listPurchaseDetailCutProcess;
    }

    public void setListPurchaseDetailCutProcess(List<PurchaseDetailCutProcess> listPurchaseDetailCutProcess) {
        this.listPurchaseDetailCutProcess = listPurchaseDetailCutProcess;
    }

    public String getInitDateCuProcess() {
        return initDateCuProcess;
    }

    public void setInitDateCuProcess(String initDateCuProcess) {
        this.initDateCuProcess = initDateCuProcess;
    }

    public String getEndDateCutProcess() {
        return endDateCutProcess;
    }

    public void setEndDateCutProcess(String endDateCutProcess) {
        this.endDateCutProcess = endDateCutProcess;
    }

    public BalanceEmployeeManager getBalanceEmployeeManager() {
        return balanceEmployeeManager;
    }

    public void setBalanceEmployeeManager(BalanceEmployeeManager balanceEmployeeManager) {
        this.balanceEmployeeManager = balanceEmployeeManager;
    }

    public PeriodPaymentEmployeeManager getPeriodPaymentEmployeeManager() {
        return periodPaymentEmployeeManager;
    }

    public void setPeriodPaymentEmployeeManager(PeriodPaymentEmployeeManager periodPaymentEmployeeManager) {
        this.periodPaymentEmployeeManager = periodPaymentEmployeeManager;
    }

    public List<CutProcess> getListCutProcess() {
        return listCutProcess;
    }

    public void setListCutProcess(List<CutProcess> listCutProcess) {
        this.listCutProcess = listCutProcess;
    }

    public Map getReportParams() {
        return reportParams;
    }

    public void setReportParams(Map reportParams) {
        this.reportParams = reportParams;
    }

    public TransactionUserManager getTransactionUserManager() {
        return transactionUserManager;
    }

    public void setTransactionUserManager(TransactionUserManager transactionUserManager) {
        this.transactionUserManager = transactionUserManager;
    }
   
}
